{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "1、针对分类问题，改变激活函数为selu，观察准确率差异",
   "id": "b4273766969de575"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:02.910882Z",
     "start_time": "2025-03-07T11:11:00.855236Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import tqdm.auto as tqdm\n",
    "import sklearn\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n"
   ],
   "id": "bfc387a130b7dcc2",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "显示系统硬件信息",
   "id": "45ac5a3e893227aa"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:02.929468Z",
     "start_time": "2025-03-07T11:11:02.910882Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(sys.version_info)\n",
    "for moudle in np, pd, sklearn, mpl, torch:\n",
    "    print(moudle.__name__, moudle.__version__)\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n"
   ],
   "id": "51e9347961ed87bb",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "matplotlib 3.9.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 准备数据和数据预处理",
   "id": "43904d6b561b4635"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.876787Z",
     "start_time": "2025-03-07T11:11:02.929468Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets  # 加载数据集\n",
    "from torchvision import transforms  # 将图片转换为tensor\n",
    "\n",
    "# 定义数据集的变换\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # 将图片转换为tensor\n",
    "    # transforms.Normalize((0.1307,), (0.3081,))  # 归一化\n",
    "])\n",
    "\n",
    "# fashion MNIST 数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分"
   ],
   "id": "3f6581b9e9eccb7",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.880518Z",
     "start_time": "2025-03-07T11:11:03.876787Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 打印数据集信息\n",
    "print(train_ds)\n",
    "# 打印测试集的信息\n",
    "print('-' * 50)\n",
    "print(test_ds)"
   ],
   "id": "43ef446a782874e8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset FashionMNIST\n",
      "    Number of datapoints: 60000\n",
      "    Root location: data\n",
      "    Split: Train\n",
      "    StandardTransform\n",
      "Transform: Compose(\n",
      "               ToTensor()\n",
      "           )\n",
      "--------------------------------------------------\n",
      "Dataset FashionMNIST\n",
      "    Number of datapoints: 10000\n",
      "    Root location: data\n",
      "    Split: Test\n",
      "    StandardTransform\n",
      "Transform: Compose(\n",
      "               ToTensor()\n",
      "           )\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.895367Z",
     "start_time": "2025-03-07T11:11:03.881523Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 将数据转存到DataLoaders中,只有训练集需要shuffle。\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True)\n",
    "# 把测试数据也转存到DataLoaders中，变成一个batch\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=32, shuffle=False)\n",
    "# 打印DataLoaders的类型\n",
    "print(type(train_loader))\n",
    "# 查看在dataloader中取出的batch的大小\n",
    "print('-' * 50)\n",
    "for data in train_loader:\n",
    "    print(type(data))\n",
    "    print(type(data[0]))\n",
    "    print(data[0].shape)\n",
    "    print(type(data[1]))\n",
    "    print(data[1].shape)\n",
    "    break\n",
    "print('-' * 50)\n",
    "for data, label in train_loader:\n",
    "    print(data.shape)\n",
    "    print(label.shape)\n",
    "    break"
   ],
   "id": "28b7aa8bc6717aae",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torch.utils.data.dataloader.DataLoader'>\n",
      "--------------------------------------------------\n",
      "<class 'list'>\n",
      "<class 'torch.Tensor'>\n",
      "torch.Size([32, 1, 28, 28])\n",
      "<class 'torch.Tensor'>\n",
      "torch.Size([32])\n",
      "--------------------------------------------------\n",
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义模型",
   "id": "f29b95d11abd31be"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.899637Z",
     "start_time": "2025-03-07T11:11:03.895367Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        # 调用父类的初始化方法\n",
    "        super().__init__()\n",
    "        # 定义网络结构\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 300),  # 输入层到隐藏层\n",
    "            nn.ReLU(),  # 激活函数\n",
    "            nn.Linear(300, 100),  # 隐藏层到输出层\n",
    "            nn.ReLU(),  # 激活函数\n",
    "            nn.Linear(100, 10),  # 输出层\n",
    "        )\n",
    "\n",
    "    # 定义前向传播过程\n",
    "    def forward(self, x):\n",
    "        # 定义前向传播过程\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "model = NeuralNetwork()"
   ],
   "id": "adae75e7c6f88492",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "4b52a1afb420335d"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "pytorch的训练需要自行实现：\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义tensorboard\n",
    "4. 定义earlystopping\n",
    "5. 定义checkpoint\n",
    "6. 定义训练循环，步数\n",
    "7. 训练"
   ],
   "id": "996beb88c8590b3c"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "定义损失器和优化器",
   "id": "8657cd69cdaff902"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.930660Z",
     "start_time": "2025-03-07T11:11:03.899637Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# 定义损失函数,nn.CrossEntropyLoss()是多分类用的损失函数,叫做交叉熵\n",
    "loss_func = nn.CrossEntropyLoss()\n",
    "# 定义优化器,SGD是随机梯度下降法,momentum是动量法,lr是学习率\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)"
   ],
   "id": "42c794a66bba835f",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "定义earlystopping",
   "id": "d3c31fb7587c4a09"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.934646Z",
     "start_time": "2025-03-07T11:11:03.930660Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStoppingCallback:\n",
    "    # c\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "        早停（Early Stopping）回调类，用于在训练过程中监控模型性能，防止过拟合。\n",
    "        当验证集上的性能在连续 `patience` 个 epoch 内没有改善时，停止训练。\n",
    "        Args:\n",
    "            patience (int, optional): \n",
    "                在训练停止前，可以容忍验证集性能没有改善的最大 epoch 数。\n",
    "                例如，如果 `patience=5`，则在验证集性能连续 5 个 epoch 没有改善时，训练将停止。\n",
    "                默认值为 5。\n",
    "                \n",
    "            min_delta (float, optional): \n",
    "                监控指标的最小变化量，用于判断是否算作性能改善。\n",
    "                如果验证集性能的变化量小于 `min_delta`，则认为性能没有改善。\n",
    "                例如，如果 `min_delta=0.01`，则验证集性能的变化必须大于 0.01 才算作改善。\n",
    "                默认值为 0.01。\n",
    "        \"\"\"\n",
    "        self.patience = patience  # 容忍度\n",
    "        self.min_delta = min_delta  # 最小变化\n",
    "        self.best_metric = -1  # 初始化最佳指标为-1\n",
    "        self.counter = 0  # 计数器，记录连续多少个epoch没有提升\n",
    "\n",
    "    # 定义__call__方法，在训练过程中调用.回调函数的入口，会在训练过程中调用\n",
    "    def __call__(self, metric):\n",
    "        \"\"\"\n",
    "        回调函数，在每个 epoch 结束后调用，检查是否需要停止训练。\n",
    "        Args:\n",
    "            current_metric (float): 当前 epoch 的验证集性能指标。\n",
    "        Returns:\n",
    "            bool: 如果需要停止训练，返回 True；否则返回 False。\n",
    "        \"\"\"\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果当前指标大于或等于最佳指标+最小变化\n",
    "            self.best_metric = metric  # 更新最佳指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加1\n",
    "\n",
    "    @property  # 定义@property装饰器，使得实例可以像属性一样访问patience和min_delta\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience  # 如果计数器大于或等于容忍度，则返回True，表示停止训练"
   ],
   "id": "5b0d0239b96c8544",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义评估函数",
   "id": "18407eb1797c1979"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.942105Z",
     "start_time": "2025-03-07T11:11:03.934646Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluating(model, dataloader, loss_func):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 正向传播\n",
    "        logits = model(datas)\n",
    "\n",
    "        loss = loss_func(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "f946e5e5c8bf8fb7",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "3c7be1e3fd244e21"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:11:03.948550Z",
     "start_time": "2025-03-07T11:11:03.942105Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# \n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_func,\n",
    "        optimizer,\n",
    "        early_stopping_callback=None,\n",
    "        sval_step=500):\n",
    "    \"\"\"\n",
    "    训练函数，用于训练模型并监控验证集性能。\n",
    "    Args:\n",
    "        model: 要训练的模型。\n",
    "        train_loader: 训练数据加载器，提供训练数据和标签。\n",
    "        val_loader: 验证数据加载器，提供验证数据和标签。\n",
    "        epoch: 总的训练轮数。\n",
    "        loss_func: 损失函数，用于计算模型的损失。\n",
    "        optimizer: 优化器，用于更新模型的参数。\n",
    "        tensorboard_callback: TensorBoard 回调函数，用于记录训练过程中的指标。\n",
    "        save_checkpoint_callback: 保存检查点的回调函数，用于保存模型。\n",
    "        early_stopping_callback: 早停回调函数，用于防止过拟合。\n",
    "        sval_step (int, optional): 每隔多少步进行一次验证。默认为500。\n",
    "    \"\"\"\n",
    "    record_dict = {\n",
    "        \"train\": [],  # 记录训练过程中的指标\n",
    "        \"val\": []  # 记录验证过程中的指标\n",
    "    }\n",
    "    # 全局步数\n",
    "    global_step = 0\n",
    "    # 切换到训练模式\n",
    "    model.train()\n",
    "    # 使用 tqdm 显示进度条，总步数为 sval_step\n",
    "    with tqdm.tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # 遍历训练数据加载器，获取数据和标签\n",
    "            for datas, labels in train_loader:\n",
    "                # 把数据转存到device\n",
    "                datas = datas.to(device)\n",
    "                # 把标签转存到device\n",
    "                labels = labels.to(device)\n",
    "                # # 优化器梯度清零，避免梯度累积\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算，获取输出\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_func(logits, labels)\n",
    "                #  损失反向传播，计算梯度\n",
    "                loss.backward()\n",
    "                # # 优化器更新模型参数\n",
    "                optimizer.step()\n",
    "                # 获取预测类别\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                # 将损失从 GPU 移到 CPU，并转换为 Python 标量\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "                # 切换回训练模式\n",
    "                model.train()\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % sval_step == 0:\n",
    "                    # 验证模式\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_func)\n",
    "                    record_dict[\"val\"].append({  # 记录验证过程中的指标\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    # 切换回训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 3、early_stopping_callback\n",
    "                    if early_stopping_callback is not None:\n",
    "                        early_stopping_callback(val_acc)\n",
    "                        if early_stopping_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                # 全局步数加1\n",
    "                global_step += 1\n",
    "                # 进度条更新\n",
    "                pbar.update(1)\n",
    "                # 进度条显示\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n"
   ],
   "id": "21a1d7f40c15d95c",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:12:27.850666Z",
     "start_time": "2025-03-07T11:11:03.948550Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 10\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStoppingCallback(patience=10)\n",
    "# early_stop_callback = None\n",
    "model = model.to(device)\n",
    "# 训练\n",
    "record = training(model,\n",
    "                  train_loader,\n",
    "                  val_loader,\n",
    "                  epoch,\n",
    "                  loss_func,\n",
    "                  optimizer,\n",
    "                  early_stop_callback,\n",
    "                  sval_step=1000\n",
    "                  )\n"
   ],
   "id": "523a6f503740116",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/18750 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "c094c8d2a12040139f0a23dbb0c7b390"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 画图观察损失和准确率变化",
   "id": "f7615abbb4f647ca"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:12:27.944543Z",
     "start_time": "2025-03-07T11:12:27.850666Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "    # print(train_df.head())\n",
    "    # print(val_df.head())\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)  #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))  #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        #index是步数，item是指标名字\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data = range(0, train_df.index[-1], 5000)  #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))  #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "id": "4228f1cf03030315",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:12:28.596349Z",
     "start_time": "2025-03-07T11:12:27.945546Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", weights_only=True, map_location=\"cuda:0\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_func)\n",
    "print(f\"loss:{loss:.4f}\\naccuracy:{acc:.4f}\")"
   ],
   "id": "e135039b3c0cbf3f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:0.4065\n",
      "accuracy:0.8561\n"
     ]
    }
   ],
   "execution_count": 13
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
